/**
 * 文档管理API服务
 * 提供文档和分类的增删改查功能
 * 支持自动切换Mock数据和真实API
 */

import ApiClient from '../client.js';
import { API_CONFIG, API_ENDPOINTS } from '../config.js';
import { createModuleAdapter } from '../adapters/api-adapter.js';
import { 
  documentMockService,
  categoryMockService,
  authMockService
} from '../mock-data/documentation-mock.js';

/**
 * 文档真实API服务类
 * 负责调用后端Java Spring Boot API
 */
class DocumentRealApiService {
    constructor() {
        this.client = new ApiClient();
        this.client.baseURL = API_CONFIG.DOCUMENTATION.BASE_URL;
    }

    /**
     * 获取文档列表
     * @param {object} params - 查询参数
     * @returns {Promise} 分页数据
     */
    async getList(params = {}) {
        // ApiClient 已自动提取 ApiResponse 的 data 字段
        // 返回的 result 已经是 PageResponse 对象 { data: [...], page, pageSize, total, totalPages }
        const result = await this.client.get('/documents', {
            query: params,
        });
        // 直接返回 PageResponse 对象，不需要再提取 data
        return result;
    }

    /**
     * 根据slug获取文档详情
     * @param {string} slug - 文档slug
     * @returns {Promise} 文档对象
     */
    async getBySlug(slug) {
        const result = await this.client.get(`/documents/${slug}`);
        return result?.data ?? result;
    }

    /**
     * 根据ID获取文档详情
     * @param {number} id - 文档ID
     * @returns {Promise} 文档对象
     */
    async getById(id) {
        const result = await this.client.get(`/documents/id/${id}`);
        return result?.data ?? result;
    }

    /**
     * 创建文档
     * @param {object} data - 文档数据
     * @returns {Promise} 新文档对象
     */
    async create(data) {
        const result = await this.client.post('/documents', data);
        return result?.data ?? result;
    }

    /**
     * 更新文档
     * @param {number} id - 文档ID
     * @param {object} data - 更新数据
     * @returns {Promise} 更新后的文档对象
     */
    async update(id, data) {
        const result = await this.client.put(`/documents/${id}`, data);
        return result?.data ?? result;
    }

    /**
     * 删除文档
     * @param {number} id - 文档ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
        const result = await this.client.delete(`/documents/${id}`);
        return result?.data ?? result;
    }

    /**
     * 增加文档浏览量
     * @param {number} id - 文档ID
     * @returns {Promise} 操作结果
     */
    async incrementView(id) {
        const result = await this.client.post(`/documents/${id}/increment-view`);
        return result?.data ?? result;
    }
}

/**
 * 分类真实API服务类
 */
class CategoryRealApiService {
    constructor() {
        this.client = new ApiClient();
        this.client.baseURL = API_CONFIG.DOCUMENTATION.BASE_URL;
    }

    /**
     * 获取所有分类
     * @param {boolean} flat - 是否返回平铺列表
     * @returns {Promise} 分类列表
     */
    async getAll(flat = false) {
        const query = flat ? { flat: true } : {};
        const result = await this.client.get('/categories', { query });
        return result?.data ?? result;
    }

    /**
     * 根据ID获取分类详情
     * @param {number} id - 分类ID
     * @returns {Promise} 分类对象
     */
    async getById(id) {
        const result = await this.client.get(`/categories/${id}`);
        return result?.data ?? result;
    }

    /**
     * 创建分类
     * @param {object} data - 分类数据
     * @returns {Promise} 新分类对象
     */
    async create(data) {
        const result = await this.client.post('/categories', data);
        return result?.data ?? result;
    }

    /**
     * 更新分类
     * @param {number} id - 分类ID
     * @param {object} data - 更新数据
     * @returns {Promise} 更新后的分类对象
     */
    async update(id, data) {
        const result = await this.client.put(`/categories/${id}`, data);
        return result?.data ?? result;
    }

    /**
     * 删除分类
     * @param {number} id - 分类ID
     * @returns {Promise} 删除结果
     */
    async delete(id) {
        const result = await this.client.delete(`/categories/${id}`);
        return result?.data ?? result;
    }
}

/**
 * 认证真实API服务类
 */
class AuthRealApiService {
    constructor() {
        this.client = new ApiClient();
        this.client.baseURL = API_CONFIG.AUTH?.BASE_URL
            || API_CONFIG.DOCUMENTATION.BASE_URL.replace('/v1', '/v1/auth');
    }

    /**
     * 用户登录
     * @param {object} credentials - 登录凭证
     * @returns {Promise} 认证响应
     */
    async login(credentials) {
        const result = await this.client.post('/login', credentials);
        return result?.data ?? result;
    }

    /**
     * 用户注册
     * @param {object} userData - 用户数据
     * @returns {Promise} 认证响应
     */
    async register(userData) {
        const result = await this.client.post('/register', userData);
        return result?.data ?? result;
    }

    /**
     * 刷新Token
     * @param {string} refreshToken - 刷新令牌
     * @returns {Promise} 认证响应
     */
    async refresh(refreshToken) {
        const result = await this.client.post(`/refresh`, null, {
            query: { refreshToken },
        });
        return result?.data ?? result;
    }
}

// 创建适配器实例
// 文档管理适配器
const documentAdapter = createModuleAdapter(
    'DOCUMENTATION',
    documentMockService,  // 使用 Mock 服务对象
    new DocumentRealApiService()
);

// 分类管理适配器
const categoryAdapter = createModuleAdapter(
    'DOCUMENTATION',
    categoryMockService,  // 使用 Mock 服务对象
    new CategoryRealApiService()
);

// 认证适配器
const authAdapter = createModuleAdapter(
    'DOCUMENTATION',
    authMockService,  // 使用 Mock 服务对象
    new AuthRealApiService()
);

/**
 * 文档管理服务
 * 对外提供统一的API接口
 */
export const documentService = {
    /**
     * 获取文档列表
     * @param {object} params - 查询参数
     * @param {number} params.page - 页码（默认1）
     * @param {number} params.pageSize - 每页数量（默认10）
     * @param {number} params.categoryId - 分类ID筛选
     * @param {string} params.status - 状态筛选（draft/published/archived）
     * @param {string} params.keyword - 搜索关键词
     * @param {string} params.tags - 标签筛选（逗号分隔）
     * @param {string} params.sortBy - 排序字段（默认createdAt）
     * @param {string} params.sortOrder - 排序方向（默认desc）
     * @returns {Promise<object>} 分页数据
     * 
     * 示例：
     * const result = await documentService.getList({
     *   page: 1,
     *   pageSize: 20,
     *   categoryId: 1,
     *   status: 'published',
     *   keyword: 'Java'
     * });
     */
    async getList(params) {
        return documentAdapter.get('getList', params);
    },

    /**
     * 根据slug获取文档详情
     * @param {string} slug - 文档slug
     * @returns {Promise<object>} 文档对象
     * 
     * 示例：
     * const doc = await documentService.getBySlug('java-getting-started');
     */
    async getBySlug(slug) {
        return documentAdapter.get('getBySlug', slug);
    },

    /**
     * 根据ID获取文档详情
     * @param {number} id - 文档ID
     * @returns {Promise<object>} 文档对象
     */
    async getById(id) {
        return documentAdapter.get('getById', id);
    },

    /**
     * 创建文档
     * @param {object} data - 文档数据
     * @param {string} data.title - 标题（必填）
     * @param {string} data.slug - 唯一标识符（必填）
     * @param {string} data.summary - 摘要
     * @param {string} data.content - 内容
     * @param {string} data.contentType - 内容类型（默认direct）
     * @param {number} data.categoryId - 分类ID
     * @param {Array<string>} data.tags - 标签列表
     * @param {string} data.status - 状态（默认draft）
     * @param {boolean} data.isPublic - 是否公开（默认true）
     * @param {string} data.language - 语言（默认zh-CN）
     * @returns {Promise<object>} 新文档对象
     * 
     * 示例：
     * const newDoc = await documentService.create({
     *   title: 'Java入门',
     *   slug: 'java-intro',
     *   content: '# Java入门\n\n...',
     *   categoryId: 2,
     *   tags: ['java', '入门'],
     *   status: 'published'
     * });
     */
    async create(data) {
        return documentAdapter.post('create', data);
    },

    /**
     * 更新文档
     * @param {number} id - 文档ID
     * @param {object} data - 更新数据（支持部分更新）
     * @returns {Promise<object>} 更新后的文档对象
     * 
     * 示例：
     * const updated = await documentService.update(1, {
     *   title: '新标题',
     *   status: 'published'
     * });
     */
    async update(id, data) {
        return documentAdapter.put('update', id, data);
    },

    /**
     * 删除文档
     * @param {number} id - 文档ID
     * @returns {Promise<boolean>} 是否成功
     * 
     * 示例：
     * await documentService.delete(1);
     */
    async delete(id) {
        return documentAdapter.delete('delete', id);
    },

    /**
     * 增加文档浏览量
     * @param {number} id - 文档ID
     * @returns {Promise} 操作结果
     * 
     * 示例：
     * await documentService.incrementView(1);
     */
    async incrementView(id) {
        return documentAdapter.post('incrementView', id);
    }
};

/**
 * 分类管理服务
 * 对外提供统一的分类API接口
 */
export const categoryService = {
    /**
     * 获取所有分类
     * @param {boolean} flat - 是否返回平铺列表（默认false，返回树形结构）
     * @returns {Promise<Array>} 分类列表
     * 
     * 示例（树形结构）：
     * const categories = await categoryService.getAll();
     * 
     * 示例（平铺列表）：
     * const flatCategories = await categoryService.getAll(true);
     */
    async getAll(flat = false) {
        return categoryAdapter.get('getAll', flat);
    },

    /**
     * 根据ID获取分类详情
     * @param {number} id - 分类ID
     * @returns {Promise<object>} 分类对象
     * 
     * 示例：
     * const category = await categoryService.getById(1);
     */
    async getById(id) {
        return categoryAdapter.get('getById', id);
    },

    /**
     * 创建分类
     * @param {object} data - 分类数据
     * @param {string} data.name - 分类名称（必填）
     * @param {string} data.slug - 唯一标识符（必填）
     * @param {string} data.description - 描述
     * @param {string} data.icon - 图标
     * @param {number} data.parentId - 父分类ID
     * @param {number} data.sortOrder - 排序顺序
     * @returns {Promise<object>} 新分类对象
     * 
     * 示例：
     * const newCategory = await categoryService.create({
     *   name: 'JavaScript',
     *   slug: 'javascript',
     *   description: 'JavaScript相关文档',
     *   parentId: 4,
     *   sortOrder: 3
     * });
     */
    async create(data) {
        return categoryAdapter.post('create', data);
    },

    /**
     * 更新分类
     * @param {number} id - 分类ID
     * @param {object} data - 更新数据
     * @returns {Promise<object>} 更新后的分类对象
     * 
     * 示例：
     * const updated = await categoryService.update(1, {
     *   description: '新的描述'
     * });
     */
    async update(id, data) {
        return categoryAdapter.put('update', id, data);
    },

    /**
     * 删除分类
     * @param {number} id - 分类ID
     * @returns {Promise<boolean>} 是否成功
     * 
     * 示例：
     * await categoryService.delete(1);
     */
    async delete(id) {
        return categoryAdapter.delete('delete', id);
    }
};

/**
 * 认证服务
 * 对外提供统一的认证API接口
 */
export const authService = {
    /**
     * 用户登录
     * @param {object} credentials - 登录凭证
     * @param {string} credentials.email - 邮箱或用户名
     * @param {string} credentials.password - 密码
     * @returns {Promise<object>} 认证响应（包含token和用户信息）
     * 
     * 示例：
     * const authData = await authService.login({
     *   email: 'admin@example.com',
     *   password: 'admin123'
     * });
     */
    async login(credentials) {
        return authAdapter.post('login', credentials);
    },

    /**
     * 用户注册
     * @param {object} userData - 用户数据
     * @param {string} userData.email - 邮箱
     * @param {string} userData.username - 用户名
     * @param {string} userData.password - 密码
     * @param {string} userData.fullName - 真实姓名
     * @returns {Promise<object>} 认证响应
     * 
     * 示例：
     * const authData = await authService.register({
     *   email: 'newuser@example.com',
     *   username: 'zhangsan',
     *   password: 'password123',
     *   fullName: '张三'
     * });
     */
    async register(userData) {
        return authAdapter.post('register', userData);
    },

    /**
     * 刷新Token
     * @param {string} refreshToken - 刷新令牌
     * @returns {Promise<object>} 新的认证响应
     * 
     * 示例：
     * const authData = await authService.refresh(oldRefreshToken);
     */
    async refresh(refreshToken) {
        return authAdapter.get('refresh', refreshToken);
    }
};

// 默认导出
export default documentService;
